Introducción a POSIX (Portable Operating System Interface + UniX) (página 2)

Partes: 1, 2

Ejemplo con fork()
#include
int main(void) {
pid_t id;
id = fork();
if (id == -1) {
perror (“Error en el fork”);
exit (1);
}
if (id == 0) {
while (1) printf (“Hola: soy el hijon”);
} else {
while (1) printf (“Hola: soy el padren”);
}
} /* Fin de main */

Ejecución de programas: exec()
La familia de llamadas exec() se emplea para cargar la imagen de un proceso desde un archivo a memoria
La nueva imagen se carga encima de la del proceso que invoca la llamada, machacándolo
El nuevo proceso hereda:
El PID y el PPID del proceso original
La política de planificación
Las alarmas y señales pendientes

Prototipos de la familia exec()
Definidos en:
#include
int execl (const char *path,
const char *arg, …);
int execlp (const char *file,
const char *arg, …);
int execle (const char *path, const char *arg,
…, char * const envp[]);
int execv (const char *path, char const *argv[]);
int execvp (const char *file, char const *argv[]);
Valores de retorno:
En caso de error exec() devuelve -1

Ejemplo con exec()
#include
int main(void) {
int ret;
char *arg[3];
arg[0] = “ls”;
arg[1] = “-l”;
arg[2] = (char *)0;
printf (“Allá va!n”);
ret = execv (“/bin/ls”, arg);
if (ret == -1) {
perror (“Error en el exec”);
exit (1);
}
} /* Fin de main */

Finalización de procesos: exit()
La llamada exit() provoca la finalización del proceso que la invoca
Esta llamada nunca retorna
Cuando un proceso termina, sus hijos no mueren y suelen ser adoptados por el proceso init
Prototipo definido en:
#include
void _exit (int status);
El valor status es retornado al padre si es que existe

Espera por procesos: wait()
La llamada wait() permite que un proceso quede esperando a que sus hijos terminen
El padre puede conocer el valor de retorno de cada hijo
Prototipos definido en:
#include
#include
pid_t wait (int *status);
pid_t waitpid(pid_t pid, int *status, int
options);

Ejemplo con wait()
#include
#include
int main(void)
{
pid_t id;
int estado;
id = fork();
if (id == -1) {
perror (“Error en el fork”);
exit (1);
}

Continuación del ejemplo
if (id == 0) {
printf (“Soy el hijon”);
sleep(3);
printf (“Hijo: despierta y finalizan”);
exit(0);
} else {
printf (“Soy el padre y ahora espero …n”);
wait (&estado);
printf (“Padre: el hijo terminó con estado =
%dn”, estado);
exit (0);
}
} /* Fin de main */

Planificación
Los mecanismos clásicos de planificación no son válidos
Es necesario evitar el indeterminismo
POSIX 1b utiliza una planificación expulsora con prioridades fijas (32 como mínimo) con tres políticas diferentes:
SCHED_FIFO
FIFO para tareas de igual prioridad
SCHED_RR
Round-Robin en tareas con la misma prioridad. El quanto es fijo
SCHED_OTHER
Definido por la realización concreta

Planificación (continuación)
Los parámetros de planificación y los prototipos de las funciones se encuentran en:
#include
Parámetros de planificación:
struct sched_param {
int sched_priority;
}
Definir política y parámetros (hay que ser root):
int sched_setscheduler (pid_t pid,int policy,
const struct sched_param *param);

Planificación (continuación)
Leer la política y los parámetros:
int sched_getscheduler (pid_t pid);
int sched_getparam (pid_t pid,
struct sched_param *param);
Ceder el procesador:
int sched_yield (void);
Leer los límites de los parámetros:
int sched_get_priority_max (int policy);
int sched_get_priority_min (int policy);
int sched_rr_get_interval (pid_t pid,
struct timespec *interval);

Ejemplo
#include
#include

int main(void) {
pid_t pid;
struct sched_param parametros;
int i, max_prio;
pid = getpid();
max_prio = sched_get_priority_max(SCHED_FIFO);
parametros.sched_priority = max_prio;
sched_setscheduler(pid, SCHED_FIFO, ¶metros);
for (i=0; i<100000000; i++);
} /* Fin de main */

Introducción
La memoria virtual introduce NO determinismo
POSIX proporciona la posibilidad de bloquear memoria para evitar la aleatoriedad
Los procesos a pesar de tener un espacio de direccionamiento disjunto pueden compartir objetos de memoria
La compartición se realiza mapeando la zona de memoria que deseamos compartir en los espacios de direccionamiento virtuales de cada proceso
La compartición se realiza a través de páginas de modo que el tamaño de una zona proyectada es un múltiplo del tamaño de la página

Bloqueo de memoria
Los procesos pueden bloquear todas sus páginas en memoria para evitar el intercambio con el disco
#include
int mlockall (int flags);
El valor de flags puede ser:
MCL_CURRENT: afecta a las páginas actuales
MCL_FUTURE: afecta a las páginas futuras
Para liberar todas las páginas del proceso:
int munlockall (void);

Bloqueo de memoria
Un proceso pueden bloquear también un rango de su espacio de direccionamiento
int mlock (const void *addr, size_t len);
Para desbloquear un rango de direcciones:
int munlock (const void *addr, size_t len);

Memoria compartida
M. Compartida
M. Compartida
M. Compartida
Proceso 1
Proceso 2
Memoria física

Proyección de objetos en memoria
La llamada mmap() permite proyectar objetos en memoria
Estos objetos pueden ser compartidos
Función mmap():
void *mmap (void *addr, size_t len, int prot,
int flags, int fildes, off_t off);
El objeto queda identificado por fildes
len y off son la longitud y el offset del objeto en bytes respectivamente
addr es la dirección donde deseamos proyectar el objeto preferiblemente. Es sólo una indicación

Proyección de objetos en memoria
La dirección real donde se proyecta el objeto es devuelta por mmap()y depende del valor de flags:
MAP_FIXED: addr se interpreta de forma exacta, sin este flag si addr vale NULL, el sistema elige la dirección
MAP_SHARED: los cambios son compartidos
MAP_PRIVATE: no se comparten los cambios
prot especifica el tipo de acceso:
PROT_READ: derecho de lectura
PROT_WRITE: derecho de escritura
PROT_EXEC: derecho de ejecución
PROT_NONE: sin derechos

Proyección de objetos en memoria
Para eliminar la proyección de un objeto en memoria emplearemos la función munmap()
int munmap (void *addr, size_t len);

Objetos de memoria compartida
Para abrir un objeto de memoria compartida:
#include
int shm_open (const char *path, int oflag,
mode_t mode );
Se establece una conexión entre el path que identifica al objeto y el descriptor devuelto
oflag determina el modo de acceso
mode determina los derechos de acceso si creamos un nuevo objeto
Es recomendable por razones de portabilidad que el path comience con el carácter /

Objetos de memoria compartida
Fijar el tamaño de un objeto de memoria compartida
int ftruncate (int fildes, off_t length);
Para borrar un objeto de memoria compartida:
int shm_unlink (const char *path);